/**
 * 邮件服务模块
 * 处理所有邮件相关功能
 */

const nodemailer = require('nodemailer');
const logger = require('../utils/logger');
const SummaryService = require('./summaryService');

class EmailService {
  constructor() {
    this.transporter = null;
    this.recipients = [];
    this.checkInterval = 3000;
    this.summaryService = new SummaryService();
    this.init();
  }

  /**
   * 初始化邮件服务
   */
  init() {
    // 邮件发送配置
    this.transporter = nodemailer.createTransport({
      host: process.env.EMAIL_HOST || 'smtp.qq.com',
      port: parseInt(process.env.EMAIL_PORT) || 465,
      secure: process.env.EMAIL_SECURE !== 'false',
      auth: {
        user: process.env.EMAIL_USER,
        pass: process.env.EMAIL_PASS
      }
    });

    // 收件人列表
    this.recipients = process.env.EMAIL_RECIPIENTS 
      ? process.env.EMAIL_RECIPIENTS.split(',').map(email => email.trim())
      : ['573843273@qq.com', '675766596@qq.com'];

    // 检查间隔
    this.checkInterval = parseInt(process.env.CHECK_INTERVAL) || 3000;
  }

  /**
   * 验证邮件配置
   * @returns {Promise<boolean>} 验证结果
   */
  async verifyConfig() {
    if (!process.env.EMAIL_USER || !process.env.EMAIL_PASS) {
      logger.warn('邮件配置不完整，将跳过邮件发送');
      return false;
    }

    try {
      await this.transporter.verify();
      logger.success('邮件配置验证成功');
      return true;
    } catch (error) {
      logger.error(`邮件配置验证失败: ${error.message}`);
      return false;
    }
  }

  /**
   * 发送新增交易对通知邮件
   * @param {Array} newPairs - 新增的交易对列表（支持多交易所格式）
   */
  async sendNewPairsNotification(newPairs) {
    if (!process.env.EMAIL_USER || !process.env.EMAIL_PASS) {
      logger.warn('邮件配置不完整，跳过邮件发送');
      this.logNewPairsToConsole(newPairs);
      return;
    }

    const timestamp = new Date().toLocaleString('zh-CN', {
      timeZone: 'Asia/Shanghai'
    });

    // 检查是否为多交易所格式
    const isMultiExchange = newPairs.length > 0 && typeof newPairs[0] === 'object' && newPairs[0].exchange;
    
    let subject;
    if (isMultiExchange) {
      const exchangeNames = [...new Set(newPairs.map(p => p.exchangeName))];
      subject = `🚀 多交易所新增交易对通知 (${exchangeNames.join(', ')}) - ${timestamp}`;
    } else {
      subject = `🚀 Upbit 新增交易对通知 - ${timestamp}`;
    }

    const mailOptions = {
      from: process.env.EMAIL_USER,
      to: this.recipients.join(','),
      subject: subject,
      html: isMultiExchange ? this.generateMultiExchangeEmailHTML(newPairs, timestamp) : this.generateEmailHTML(newPairs, timestamp),
      text: isMultiExchange ? this.generateMultiExchangeEmailText(newPairs, timestamp) : this.generateEmailText(newPairs, timestamp)
    };

    try {
      await this.transporter.sendMail(mailOptions);
      logger.success(`邮件发送成功，通知 ${this.recipients.length} 位接收者`);
    } catch (error) {
      logger.error(`邮件发送失败: ${error.message}`);
    }
  }

  /**
   * 发送测试邮件
   */
  async sendTestEmail() {
    const timestamp = new Date().toLocaleString('zh-CN', {
      timeZone: 'Asia/Shanghai'
    });

    const testNewPairs = ['BTC-TEST1', 'KRW-TEST2', 'USDT-TEST3'];

    const mailOptions = {
      from: process.env.EMAIL_USER,
      to: this.recipients.join(','),
      subject: `📧 邮件发送测试 - Upbit 交易对监控系统 - ${timestamp}`,
      html: this.generateTestEmailHTML(testNewPairs, timestamp),
      text: this.generateTestEmailText(testNewPairs, timestamp)
    };

    try {
      logger.info('🔍 验证邮件服务器连接...');
      await this.transporter.verify();
      logger.success('邮件服务器连接验证成功');
      
      logger.info('📤 正在发送测试邮件...');
      const info = await this.transporter.sendMail(mailOptions);
      
      logger.success('测试邮件发送成功！');
      logger.info(`📧 邮件ID: ${info.messageId}`);
      logger.info(`📬 发送到: ${this.recipients.join(', ')}`);
      
      return true;
    } catch (error) {
      logger.error(`测试邮件发送失败: ${error.message}`);
      this.logEmailErrorHelp(error);
      return false;
    }
  }

  /**
   * 生成邮件HTML内容
   */
  generateEmailHTML(newPairs, timestamp) {
    return `
      <h2>🎉 Upbit 发现新的交易对！</h2>
      <p><strong>检测时间：</strong>${timestamp}</p>
      <p><strong>新增交易对数量：</strong>${newPairs.length} 个</p>
      <h3>📊 新增交易对列表：</h3>
      <ul>
        ${newPairs.map(pair => `<li><code>${pair}</code></li>`).join('')}
      </ul>
      <hr>
      <p style="color: #666; font-size: 12px;">
        此邮件由 Upbit 交易对监控系统自动发送<br>
        监控频率：每 ${this.checkInterval / 1000} 秒检查一次
      </p>
    `;
  }

  /**
   * 生成邮件文本内容
   */
  generateEmailText(newPairs, timestamp) {
    return `
Upbit 新增交易对通知

检测时间：${timestamp}
新增交易对数量：${newPairs.length} 个

新增交易对列表：
${newPairs.map(pair => `- ${pair}`).join('\n')}

此邮件由 Upbit 交易对监控系统自动发送
监控频率：每 ${this.checkInterval / 1000} 秒检查一次
    `;
  }

  /**
   * 生成测试邮件HTML内容
   */
  generateTestEmailHTML(testNewPairs, timestamp) {
    return `
      <h2>📧 邮件发送功能测试</h2>
      <p><strong>测试时间：</strong>${timestamp}</p>
      <p><strong>测试目的：</strong>验证 Upbit 交易对监控系统的邮件发送功能</p>
      
      <h3>🧪 模拟新增交易对：</h3>
      <ul>
        ${testNewPairs.map(pair => `<li><code>${pair}</code></li>`).join('')}
      </ul>
      
      <h3>⚙️ 系统配置信息：</h3>
      <ul>
        <li><strong>邮件服务器：</strong>${process.env.EMAIL_HOST || 'smtp.qq.com'}</li>
        <li><strong>端口：</strong>${process.env.EMAIL_PORT || 465}</li>
        <li><strong>发送邮箱：</strong>${process.env.EMAIL_USER}</li>
        <li><strong>接收邮箱数量：</strong>${this.recipients.length} 个</li>
      </ul>
      
      <hr>
      <p style="color: #28a745; font-weight: bold;">✅ 如果您收到此邮件，说明邮件发送功能正常！</p>
      <p style="color: #666; font-size: 12px;">
        此邮件由 Upbit 交易对监控系统测试脚本发送<br>
        测试完成后，您可以运行主程序开始监控
      </p>
    `;
  }

  /**
   * 生成测试邮件文本内容
   */
  generateTestEmailText(testNewPairs, timestamp) {
    return `
邮件发送功能测试

测试时间：${timestamp}
测试目的：验证 Upbit 交易对监控系统的邮件发送功能

模拟新增交易对：
${testNewPairs.map(pair => `- ${pair}`).join('\n')}

系统配置信息：
- 邮件服务器：${process.env.EMAIL_HOST || 'smtp.qq.com'}
- 端口：${process.env.EMAIL_PORT || 465}
- 发送邮箱：${process.env.EMAIL_USER}
- 接收邮箱数量：${this.recipients.length} 个

✅ 如果您收到此邮件，说明邮件发送功能正常！

此邮件由 Upbit 交易对监控系统测试脚本发送
测试完成后，您可以运行主程序开始监控
    `;
  }

  /**
   * 记录邮件错误帮助信息
   */
  logEmailErrorHelp(error) {
    logger.info('🔧 可能的解决方案：');
    
    if (error.code === 'EAUTH') {
      logger.info('   1. 检查邮箱和密码是否正确');
      logger.info('   2. 如果使用QQ邮箱，确保使用的是授权码而不是登录密码');
      logger.info('   3. 确保已开启SMTP服务');
    } else if (error.code === 'ESOCKET') {
      logger.info('   1. 检查网络连接');
      logger.info('   2. 检查邮件服务器地址和端口');
      logger.info('   3. 尝试关闭防火墙或VPN');
    } else {
      logger.info('   1. 检查 .env 文件配置是否正确');
      logger.info('   2. 检查邮箱服务商的SMTP设置');
      logger.info('   3. 查看具体错误信息进行排查');
    }
  }

  /**
   * 获取收件人列表
   */
  getRecipients() {
    return this.recipients;
  }

  /**
   * 发送状态告警邮件
   * @param {Object} alertInfo 告警信息
   * @returns {Promise<boolean>} 发送结果
   */
  async sendAlert(alertInfo) {
    if (!this.isConfigured()) {
      logger.warn('邮件服务未配置，无法发送告警邮件');
      return false;
    }

    try {
      logger.info(`📧 正在发送状态告警邮件: ${alertInfo.subject}`);

      const mailOptions = {
        from: this.config.user,
        to: this.config.recipients,
        subject: alertInfo.subject,
        text: alertInfo.text,
        html: alertInfo.html,
        priority: alertInfo.priority || 'normal'
      };

      const result = await this.transporter.sendMail(mailOptions);
      
      logger.success(`✅ 状态告警邮件发送成功! MessageId: ${result.messageId}`);
      return true;

    } catch (error) {
      logger.error(`❌ 状态告警邮件发送失败: ${error.message}`);
      return false;
    }
  }

  /**
   * 发送日报邮件
   */
  async sendDailySummaryEmail() {
    if (!process.env.EMAIL_USER || !process.env.EMAIL_PASS) {
      logger.warn('邮件配置不完整，跳过日报邮件发送');
      return false;
    }

    try {
      logger.info('🔍 生成24小时监控汇总报告...');
      const summary = this.summaryService.generate24HoursSummary();
      
      const mailOptions = {
        from: process.env.EMAIL_USER,
        to: this.recipients.join(','),
        subject: `📊 Upbit监控日报 - ${new Date().toLocaleDateString('zh-CN')} - ${this.getSummaryStatusEmoji(summary.successRate)}`,
        html: this.summaryService.generateEmailHTML(summary),
        text: this.summaryService.generateEmailText(summary)
      };

      logger.info('📤 正在发送日报邮件...');
      await this.transporter.sendMail(mailOptions);
      
      logger.success(`日报邮件发送成功！发送到 ${this.recipients.length} 位接收者`);
      logger.info(`📈 报告摘要: ${summary.totalChecks}次检查, ${summary.newPairsFound}个新交易对, 成功率${summary.successRate}%`);
      
      return true;
    } catch (error) {
      logger.error(`日报邮件发送失败: ${error.message}`);
      this.logEmailErrorHelp(error);
      return false;
    }
  }

  /**
   * 根据成功率获取状态表情符号
   * @param {string} successRate - 成功率
   * @returns {string} 表情符号
   */
  getSummaryStatusEmoji(successRate) {
    const rate = parseFloat(successRate);
    if (isNaN(rate)) return '❓';
    if (rate >= 95) return '🟢';
    if (rate >= 90) return '🟡';
    if (rate >= 70) return '🟠';
    return '🔴';
  }

  /**
   * 记录新增交易对到控制台（邮件未配置时使用）
   * @param {Array} newPairs - 新增的交易对列表
   */
  logNewPairsToConsole(newPairs) {
    if (newPairs.length === 0) return;
    
    const isMultiExchange = newPairs.length > 0 && typeof newPairs[0] === 'object' && newPairs[0].exchange;
    
    if (isMultiExchange) {
      const groupedByExchange = newPairs.reduce((acc, pair) => {
        if (!acc[pair.exchangeName]) acc[pair.exchangeName] = [];
        acc[pair.exchangeName].push(pair.pair);
        return acc;
      }, {});
      
      for (const [exchangeName, pairs] of Object.entries(groupedByExchange)) {
        logger.info(`${exchangeName} 新增交易对: ${pairs.join(', ')}`);
      }
    } else {
      logger.info(`新增交易对: ${newPairs.join(', ')}`);
    }
  }

  /**
   * 生成多交易所邮件HTML内容
   * @param {Array} newPairs - 新增的交易对列表（多交易所格式）
   * @param {string} timestamp - 时间戳
   * @returns {string} HTML内容
   */
  generateMultiExchangeEmailHTML(newPairs, timestamp) {
    // 按交易所分组
    const groupedByExchange = newPairs.reduce((acc, pair) => {
      if (!acc[pair.exchangeName]) {
        acc[pair.exchangeName] = {
          name: pair.exchangeName,
          id: pair.exchange,
          pairs: []
        };
      }
      acc[pair.exchangeName].pairs.push(pair.pair);
      return acc;
    }, {});

    const totalCount = newPairs.length;
    const exchangeCount = Object.keys(groupedByExchange).length;

    return `
      <h2>🎉 多交易所发现新的交易对！</h2>
      <p><strong>检测时间：</strong>${timestamp}</p>
      <p><strong>涉及交易所：</strong>${exchangeCount} 个</p>
      <p><strong>新增交易对总数：</strong>${totalCount} 个</p>
      
      ${Object.values(groupedByExchange).map(exchange => `
        <div style="margin: 20px 0; padding: 15px; border: 1px solid #ddd; border-radius: 8px;">
          <h3 style="color: #2c3e50; margin-top: 0;">🏪 ${exchange.name}</h3>
          <p><strong>新增数量：</strong>${exchange.pairs.length} 个</p>
          <ul style="list-style-type: none; padding: 0;">
            ${exchange.pairs.map(pair => `<li style="background: #f8f9fa; margin: 3px 0; padding: 5px; border-radius: 3px;"><code>${pair}</code></li>`).join('')}
          </ul>
        </div>
      `).join('')}
      
      <hr>
      <p style="color: #666; font-size: 12px;">
        此邮件由多交易所交易对监控系统自动发送<br>
        监控频率：每 ${this.checkInterval / 1000} 秒检查一次
      </p>
    `;
  }

  /**
   * 生成多交易所邮件文本内容
   * @param {Array} newPairs - 新增的交易对列表（多交易所格式）
   * @param {string} timestamp - 时间戳
   * @returns {string} 文本内容
   */
  generateMultiExchangeEmailText(newPairs, timestamp) {
    const groupedByExchange = newPairs.reduce((acc, pair) => {
      if (!acc[pair.exchangeName]) {
        acc[pair.exchangeName] = {
          name: pair.exchangeName,
          pairs: []
        };
      }
      acc[pair.exchangeName].pairs.push(pair.pair);
      return acc;
    }, {});

    const totalCount = newPairs.length;
    const exchangeCount = Object.keys(groupedByExchange).length;

    let text = `
多交易所新增交易对通知

检测时间：${timestamp}
涉及交易所：${exchangeCount} 个
新增交易对总数：${totalCount} 个

详细信息：
`;

    for (const exchange of Object.values(groupedByExchange)) {
      text += `
【${exchange.name}】
新增数量：${exchange.pairs.length} 个
交易对列表：
${exchange.pairs.map(pair => `  - ${pair}`).join('\n')}
`;
    }

    text += `
此邮件由多交易所交易对监控系统自动发送
监控频率：每 ${this.checkInterval / 1000} 秒检查一次
    `;

    return text;
  }

  /**
   * 获取检查间隔
   */
  getCheckInterval() {
    return this.checkInterval;
  }
}

module.exports = EmailService;
